#pragma once
#include "thread.hpp"
#include "mutex.hpp"
#include "cond.hpp"
#include "log.hpp"
#include <queue>
using namespace mythread;
using namespace mymutex;
using namespace mycond;
using namespace mylog;

namespace ThreadPool
{
    static int default_num = 5;
    template <typename T>
    class Threadpool
    {
        void Weakup()
        {
            LOG(Level::DEBUG) << "唤醒所有线程";
            _cond.Broadcast();
        }

    public:
        Threadpool(int num = default_num) : _num(num), _runing(false)
        {
            for (int i = 0; i < num; i++)
            {
                _threadpool.emplace_back(
                    [this]()
                    {
                        HandlerTask();
                    });
            }
        }
        // void HandlerTask()
        // {
        //     // 线程执行函数...
        //     while (true)
        //     {
        //         LockGroup lgp(_mutex);
        //         {
        //             while (_taskqueue.empty())
        //             {
        //                 _cond.Wait(_mutex.GetMutex());
        //             }
        //             // 取任务
        //             T task = _taskqueue.front();
        //             _taskqueue.pop();
        //         }
        //         // 处理任务
        //         sleep(1);
        //     }
        // }
        void HandlerTask()
        {
            while (true)
            {
                LockGroup lgp(_mutex);
                {
                    while (_taskqueue.empty() && _runing)
                    {
                        _cond.Wait(_mutex.GetMutex());
                    }
                    // 取任务
                    if (_taskqueue.empty())
                    {
                        LOG(Level::DEBUG) << "线程退出";
                        break;
                    }
                    T task = _taskqueue.front();
                    _taskqueue.pop();
                }
                // 处理任务
                sleep(1);
            }
        }
        void Start()
        {
            _runing = true;
            for (auto &thread : _threadpool)
            {
                thread.Start();
            }
        }
        void Join()
        {
            for (auto &thread : _threadpool)
            {
                thread.Join();
            }
        }
        ~Threadpool()
        {
            Join();
        }
        void Stop()
        {
            _runing = false;
            Weakup();
        }

    private:
        std::vector<Thread> _threadpool; // 线程
        std::queue<T> _taskqueue;        // 任务队列
        Mutex _mutex;                    // 互斥量
        Cond _cond;                      // 条件变量
        int _num;                        // 线程数量
        bool _runing;                    // 运行状态
    };
}

// namespace ThreadPool
// {
//     static int default_num = 5;
//     template <class T>
//     class threadpool
//     {
//         // 唤醒所以线程
//         void WeakUp()
//         {
//             _cond.Broadcast();
//         }

//     public:
//         threadpool(int num = default_num) : _num(num), _runing(false)
//         {
//             for (int i = 0; i < num; i++)
//             {
//                 _threadpool.emplace_back(
//                     [this]()
//                     {
//                         HandlerTask();
//                     });
//             }
//         }
//         void Start()
//         {
//             _runing = true;
//             for (auto &thread : _threadpool)
//             {
//                 thread.Start();
//             }
//         }
//         void HandlerTask()
//         {
//             while (true)
//             {
//                 {
//                     LockGroup LockGroup(_mutex);
//                     LOG(Level::DEBUG) << "申请锁";
//                     // while (_taskqueue.empty())
//                     //    为空 && 正在运行 进入循环
//                     while (_taskqueue.empty() && _runing)
//                     {
//                         LOG(Level::DEBUG) << "Cond等待";
//                         _cond.Wait(_mutex.GetMutex());
//                     }
//                     if (_taskqueue.empty())
//                     {
//                         LOG(Level::DEBUG) << "线程退出";
//                         break;
//                     }
//                     // 取任务
//                     LOG(Level::DEBUG) << "获取任务";
//                     T t = _taskqueue.front();
//                     _taskqueue.pop();
//                 }
//                 // 处理任务
//             }
//         }
//         void stop()
//         {
//             _runing = false;
//             WeakUp();
//             LOG(Level::DEBUG) << "唤醒所有线程";
//         }
//         void Join()
//         {
//             for (auto &thread : _threadpool)
//             {
//                 thread.Join();
//             }
//         }
//         ~threadpool()
//         {
//             Join();
//         }

//     private:
//         std::vector<Thread> _threadpool;
//         int _num;
//         Mutex _mutex;
//         Cond _cond;
//         std::queue<T> _taskqueue; // 任务队列
//         bool _runing;
//     };
// }